const { STORAGE_KEY_TOKEN, STORAGE_KEY_USER_CODE, STORAGE_KEY_USER_NAME, STORAGE_KEY_USER_STEP_DATA_MODEL, STORAGE_KEY_USER_INFO, STORAGE_KEY_LAST_STEP_SYNC_TIME } = require('../constant/storage_keys.js');
const http = require('./http.js');
const userStepDataModel = require('../model/userStepData.js');

// 全局变量记录小程序是否从后台重新进入
let isAppResumedFromBackground = false;
// 全局变量记录用户开始在线的时间
let userOnlineStartTime = null;

/**
 * 设置小程序从后台重新进入状态
 * @param {boolean} resumed 是否从后台重新进入
 */
function setAppResumedFromBackground(resumed) {
  isAppResumedFromBackground = resumed;
  console.log('设置小程序后台状态:', resumed ? '从后台重新进入' : '正常前台状态');
}

/**
 * 设置用户开始在线时间
 * @param {number} startTime 开始时间戳
 */
function setUserOnlineStartTime(startTime) {
  userOnlineStartTime = startTime;
  console.log('设置用户在线开始时间:', new Date(startTime).toLocaleString());
}

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否已登录
 */
function isLoggedIn() {
  const token = wx.getStorageSync(STORAGE_KEY_TOKEN);
  const userCode = wx.getStorageSync(STORAGE_KEY_USER_CODE);
  const userName = wx.getStorageSync(STORAGE_KEY_USER_NAME);
  return !!(token && userCode && userName);
}

/**
 * 获取当前登录用户信息
 * @returns {object} 用户信息 {token, userCode, userName}
 */
function getCurrentUser() {
  const token = wx.getStorageSync(STORAGE_KEY_TOKEN);
  const userCode = wx.getStorageSync(STORAGE_KEY_USER_CODE);
  const userName = wx.getStorageSync(STORAGE_KEY_USER_NAME);
  return { token, userCode, userName };
}

/**
 * 自动登录功能
 * @returns {Promise} 返回Promise，resolve表示自动登录成功，reject表示失败
 */
function autoLogin() {
  return new Promise((resolve, reject) => {
    const { token, userCode, userName } = getCurrentUser();

    if (!token || !userCode || !userName) {
      reject(new Error('没有找到完整的登录信息'));
      return;
    }

    console.log('开始自动登录，用户工号:', userCode, '用户姓名:', userName);

    // 调用登录接口进行自动登录验证
    wx.request({
      url: http.baseURL + '/api/user/login',
      method: 'POST',
      data: {
        userCode: userCode,
        name: userName
      },
      header: {
        'content-type': 'application/json',
        'Authorization': 'Bearer ' + token
      },
      success: (res) => {
        console.log('自动登录接口返回:', res.data);
        const code = res.data.code;

        if (code === 200 && res.data.data && res.data.data.token) {
          // 更新token
          const newToken = res.data.data.token;
          wx.setStorageSync(STORAGE_KEY_TOKEN, newToken);
          console.log('自动登录成功，token已更新');

          // 检查是否需要同步微信步数
          const shouldUpdateSteps = checkStepSyncInterval();
          if (shouldUpdateSteps) {
            console.log('需要同步微信步数，开始更新');
            updateWechatSteps(userCode, userName, newToken).then(() => {
              resolve({ token: newToken, userCode, userName });
            }).catch(err => {
              console.error('更新微信步数失败:', err);
              // 即使更新步数失败，登录也算成功
              resolve({ token: newToken, userCode, userName });
            });
          } else {
            console.log('不需要同步微信步数，跳过更新');
            // 只获取用户步数信息，不更新微信步数
            getUserStepInfo(userCode, newToken).then(() => {
              resolve({ token: newToken, userCode, userName });
            }).catch(err => {
              console.error('获取用户步数信息失败:', err);
              // 即使获取步数失败，登录也算成功
              resolve({ token: newToken, userCode, userName });
            });
          }
        } else {
          console.log('自动登录失败，需要重新登录');
          clearLoginInfo();
          reject(new Error(res.data.msg || '自动登录失败'));
        }
      },
      fail: (err) => {
        console.error('自动登录网络错误:', err);
        reject(err);
      }
    });
  });
}

/**
 * 检查是否需要同步微信步数
 * @returns {boolean} 是否需要同步步数
 */
function checkStepSyncInterval() {
  const lastSyncTime = wx.getStorageSync(STORAGE_KEY_LAST_STEP_SYNC_TIME);
  const currentTime = Date.now();
  const interval = 10 * 60 * 1000; // 10分钟 = 600000毫秒
  const onlineInterval = 10 * 60 * 1000; // 10分钟 = 600000毫秒

  // 检查是否首次同步
  if (!lastSyncTime) {
    console.log('首次同步步数');
    return true;
  }

  // 检查距离上次同步是否超过2分钟
  const timeDiff = currentTime - lastSyncTime;
  console.log(`距离上次步数同步: ${Math.round(timeDiff / 1000)}秒`);

  if (timeDiff > interval) {
    console.log('距离上次同步超过2分钟，需要同步');
    return true;
  }

  // 检查用户是否从后台重新进入
  if (isAppResumedFromBackground) {
    console.log('小程序从后台重新进入，需要同步');
    return true;
  }

  // 检查用户在线时长是否超过10分钟
  if (userOnlineStartTime) {
    const onlineTime = currentTime - userOnlineStartTime;
    console.log(`用户在线时长: ${Math.round(onlineTime / 1000)}秒`);

    if (onlineTime > onlineInterval) {
      console.log('用户在线超过10分钟，需要同步');
      return true;
    }
  }

  console.log('不需要同步微信步数');
  return false;
}

/**
 * 记录步数同步时间
 */
function recordStepSyncTime() {
  wx.setStorageSync(STORAGE_KEY_LAST_STEP_SYNC_TIME, Date.now());
  console.log('记录步数同步时间:', new Date().toLocaleString());
}

/**
 * 更新微信步数数据
 * @param {string} userCode 用户工号
 * @param {string} userName 用户姓名
 * @param {string} token 用户token
 * @returns {Promise}
 */
function updateWechatSteps(userCode, userName, token) {
  return new Promise((resolve, reject) => {
    console.log('开始更新微信步数数据');

    // 1. 获取微信登录code
    wx.login({
      success: (loginRes) => {
        console.log('自动登录获取微信code成功:', loginRes);
        if (loginRes.code) {
          // 2. 获取sessionId
          wx.request({
            url: http.baseURL + '/api/user/getSessionId',
            method: 'GET',
            data: {
              code: loginRes.code,
              userCode: userCode
            },
            header: {
              'content-type': 'application/json',
              'Authorization': 'Bearer ' + token
            },
            success: (sessionRes) => {
              console.log('自动登录获取sessionId成功:', sessionRes.data);
              if (sessionRes.data.code === 200 && sessionRes.data.data && sessionRes.data.data.sessionId) {
                const sessionId = sessionRes.data.data.sessionId;

                // 3. 检查OpenId
                wx.request({
                  url: http.baseURL + '/api/user/checkOpenId',
                  method: 'GET',
                  data: {
                    code: userCode,
                    name: userName,
                    uuid: sessionId
                  },
                  header: {
                    'content-type': 'application/json',
                    'Authorization': 'Bearer ' + token
                  },
                  success: (openIdRes) => {
                    console.log('自动登录检查OpenId成功:', openIdRes.data);
                    if (openIdRes.data.code === 200) {
                      // 4. 获取微信步数
                      wx.getWeRunData({
                        success: (runRes) => {
                          console.log('自动登录获取微信步数成功:', runRes);
                          const encryptedData = runRes.encryptedData;
                          const iv = runRes.iv;

                          // 5. 解码步数数据
                          wx.request({
                            url: http.baseURL + '/api/wechat/steps/decodeWechatStep',
                            method: 'POST',
                            data: {
                              sessionId: sessionId,
                              encryptedData: encryptedData,
                              userCode: userCode,
                              iv: iv
                            },
                            header: {
                              'content-type': 'application/json',
                              'Authorization': 'Bearer ' + token
                            },
                            success: (decodeRes) => {
                              console.log('自动登录解码步数成功:', decodeRes.data);
                              if (decodeRes.data.code === 200) {
                                                                 // 6. 获取最新的用户步数信息
                                 getUserStepInfo(userCode, token).then(() => {
                                   console.log('自动登录更新步数完成');
                                   // 记录步数同步时间
                                   recordStepSyncTime();
                                   resolve();
                                 }).catch(err => {
                                   console.error('自动登录获取用户步数信息失败:', err);
                                   // 即使获取步数信息失败，也记录同步时间（因为微信步数已经成功获取）
                                   recordStepSyncTime();
                                   resolve(); // 即使失败也认为更新完成
                                 });
                              } else {
                                console.error('自动登录解码步数失败:', decodeRes.data.msg);
                                resolve(); // 即使失败也认为更新完成
                              }
                            },
                            fail: (err) => {
                              console.error('自动登录解码步数网络错误:', err);
                              resolve(); // 即使失败也认为更新完成
                            }
                          });
                        },
                        fail: (err) => {
                          console.error('自动登录获取微信步数失败:', err);
                          resolve(); // 即使失败也认为更新完成
                        }
                      });
                    } else {
                      console.error('自动登录检查OpenId失败:', openIdRes.data.msg);
                      resolve(); // 即使失败也认为更新完成
                    }
                  },
                  fail: (err) => {
                    console.error('自动登录检查OpenId网络错误:', err);
                    resolve(); // 即使失败也认为更新完成
                  }
                });
              } else {
                console.error('自动登录获取sessionId失败:', sessionRes.data.msg);
                resolve(); // 即使失败也认为更新完成
              }
            },
            fail: (err) => {
              console.error('自动登录获取sessionId网络错误:', err);
              resolve(); // 即使失败也认为更新完成
            }
          });
        } else {
          console.error('自动登录获取微信code失败');
          resolve(); // 即使失败也认为更新完成
        }
      },
      fail: (err) => {
        console.error('自动登录微信登录失败:', err);
        resolve(); // 即使失败也认为更新完成
      }
    });
  });
}

/**
 * 获取用户步数信息
 * @param {string} userCode 用户工号
 * @param {string} token 用户token
 * @returns {Promise}
 */
function getUserStepInfo(userCode, token) {
  return new Promise((resolve, reject) => {
    wx.request({
      url: http.baseURL + '/api/user/getUserStepInfo?userCode=' + userCode,
      method: 'GET',
      header: {
        'content-type': 'application/json',
        'Authorization': 'Bearer ' + token
      },
      success: (res) => {
        if (res.data && res.data.code === 200) {
          console.log('获取用户步数信息成功:', res.data.data);
          // 用Object.assign更新模型内容
          Object.assign(userStepDataModel, res.data.data);
          wx.setStorageSync(STORAGE_KEY_USER_STEP_DATA_MODEL, userStepDataModel);
          resolve(res.data.data);
        } else {
          console.error('获取用户步数信息失败:', res.data ? res.data.msg : '未知错误');
          reject(new Error(res.data ? res.data.msg : '获取用户步数信息失败'));
        }
      },
      fail: (err) => {
        console.error('获取用户步数信息网络错误:', err);
        reject(err);
      }
    });
  });
}

/**
 * 检查登录状态，如果未登录则跳转到登录页面
 * @param {string} pageName 当前页面名称（用于日志）
 * @returns {boolean} 是否已登录
 */
function checkLoginAndRedirect(pageName = '当前页面') {
  if (!isLoggedIn()) {
    console.log(`${pageName}检测到未登录，跳转到登录页面`);
    wx.redirectTo({
      url: '/pages/login/login',
      success: () => {
        console.log('跳转登录页面成功');
      },
      fail: (err) => {
        console.error('跳转登录页面失败:', err);
      }
    });
    return false;
  }

  const { userCode } = getCurrentUser();
  console.log(`${pageName}检测到已登录，用户工号:`, userCode);
  return true;
}

/**
 * 清除登录信息
 */
function clearLoginInfo() {
  wx.removeStorageSync(STORAGE_KEY_TOKEN);
  wx.removeStorageSync(STORAGE_KEY_USER_CODE);
  wx.removeStorageSync(STORAGE_KEY_USER_NAME);
  wx.removeStorageSync(STORAGE_KEY_USER_STEP_DATA_MODEL);
  wx.removeStorageSync(STORAGE_KEY_USER_INFO);
  wx.removeStorageSync(STORAGE_KEY_LAST_STEP_SYNC_TIME);
  console.log('登录信息已清除');
}

module.exports = {
  isLoggedIn,
  getCurrentUser,
  autoLogin,
  updateWechatSteps,
  getUserStepInfo,
  checkStepSyncInterval,
  recordStepSyncTime,
  checkLoginAndRedirect,
  clearLoginInfo,
  setAppResumedFromBackground,
  setUserOnlineStartTime
};
